/**
 * 文件相关的 IPC 处理模块
 */
import { ipcMain, app } from 'electron'
import fs from 'fs'
import path from 'path'
import { promisify } from 'util'

// 将回调式API转换为Promise式API
const readFileAsync = promisify(fs.readFile)
const writeFileAsync = promisify(fs.writeFile)
const mkdirAsync = promisify(fs.mkdir)
const statAsync = promisify(fs.stat)
const readdirAsync = promisify(fs.readdir)
const unlinkAsync = promisify(fs.unlink)
const rmdirAsync = promisify(fs.rmdir)

/**
 * 设置文件相关的 IPC 处理程序
 */
export function setupFileIPC(): void {
  console.log('设置文件 IPC 处理程序')

  // 获取应用数据目录
  ipcMain.handle('get-app-data-path', () => {
    return app.getPath('userData')
  })

  // 读取文件
  ipcMain.handle('read-file', async (_event, filePath: string, encoding: BufferEncoding = 'utf8') => {
    try {
      // 安全检查：确保路径不会越界访问系统文件
      const userDataPath = app.getPath('userData')
      const normalizedPath = path.normalize(filePath)
      
      if (!normalizedPath.startsWith(userDataPath) && !app.isPackaged) {
        throw new Error('安全限制：只能访问应用数据目录内的文件')
      }
      
      const data = await readFileAsync(filePath, { encoding })
      return { success: true, data }
    } catch (error: any) {
      console.error('读取文件失败:', error)
      return { success: false, error: error.message }
    }
  })

  // 写入文件
  ipcMain.handle('write-file', async (_event, filePath: string, data: string, encoding: BufferEncoding = 'utf8') => {
    try {
      // 安全检查：确保路径不会越界访问系统文件
      const userDataPath = app.getPath('userData')
      const normalizedPath = path.normalize(filePath)
      
      if (!normalizedPath.startsWith(userDataPath) && !app.isPackaged) {
        throw new Error('安全限制：只能写入应用数据目录内的文件')
      }
      
      // 确保目录存在
      const dirPath = path.dirname(filePath)
      await mkdirAsync(dirPath, { recursive: true })
      
      await writeFileAsync(filePath, data, { encoding })
      return { success: true }
    } catch (error: any) {
      console.error('写入文件失败:', error)
      return { success: false, error: error.message }
    }
  })

  // 检查文件是否存在
  ipcMain.handle('file-exists', async (_event, filePath: string) => {
    try {
      await statAsync(filePath)
      return { exists: true }
    } catch {
      return { exists: false }
    }
  })

  // 获取文件信息
  ipcMain.handle('get-file-info', async (_event, filePath: string) => {
    try {
      const stats = await statAsync(filePath)
      return {
        success: true,
        isFile: stats.isFile(),
        isDirectory: stats.isDirectory(),
        size: stats.size,
        createdAt: stats.birthtime,
        modifiedAt: stats.mtime,
        accessedAt: stats.atime
      }
    } catch (error: any) {
      console.error('获取文件信息失败:', error)
      return { success: false, error: error.message }
    }
  })

  // 列出目录内容
  ipcMain.handle('list-directory', async (_event, dirPath: string) => {
    try {
      // 安全检查：确保路径不会越界访问系统文件
      const userDataPath = app.getPath('userData')
      const normalizedPath = path.normalize(dirPath)
      
      if (!normalizedPath.startsWith(userDataPath) && !app.isPackaged) {
        throw new Error('安全限制：只能访问应用数据目录内的文件')
      }
      
      const files = await readdirAsync(dirPath)
      
      // 获取每个文件的详细信息
      const fileInfos = await Promise.all(
        files.map(async (file) => {
          const filePath = path.join(dirPath, file)
          try {
            const stats = await statAsync(filePath)
            return {
              name: file,
              path: filePath,
              isFile: stats.isFile(),
              isDirectory: stats.isDirectory(),
              size: stats.size,
              createdAt: stats.birthtime,
              modifiedAt: stats.mtime
            }
          } catch (error) {
            return {
              name: file,
              path: filePath,
              error: 'Unable to get file info'
            }
          }
        })
      )
      
      return { success: true, files: fileInfos }
    } catch (error: any) {
      console.error('列出目录内容失败:', error)
      return { success: false, error: error.message }
    }
  })

  // 删除文件
  ipcMain.handle('delete-file', async (_event, filePath: string) => {
    try {
      // 安全检查：确保路径不会越界访问系统文件
      const userDataPath = app.getPath('userData')
      const normalizedPath = path.normalize(filePath)
      
      if (!normalizedPath.startsWith(userDataPath) && !app.isPackaged) {
        throw new Error('安全限制：只能删除应用数据目录内的文件')
      }
      
      await unlinkAsync(filePath)
      return { success: true }
    } catch (error: any) {
      console.error('删除文件失败:', error)
      return { success: false, error: error.message }
    }
  })

  // 删除目录
  ipcMain.handle('delete-directory', async (_event, dirPath: string) => {
    try {
      // 安全检查：确保路径不会越界访问系统文件
      const userDataPath = app.getPath('userData')
      const normalizedPath = path.normalize(dirPath)
      
      if (!normalizedPath.startsWith(userDataPath) && !app.isPackaged) {
        throw new Error('安全限制：只能删除应用数据目录内的目录')
      }
      
      await rmdirAsync(dirPath, { recursive: true })
      return { success: true }
    } catch (error: any) {
      console.error('删除目录失败:', error)
      return { success: false, error: error.message }
    }
  })
} 